package controller

import (
	"time"

	. "gddgame.cc/galaxy/common/dsl/web"
	"gddgame.cc/galaxy/project/breeder/breeder/cooperated"
	"gddgame.cc/galaxy/project/breeder/breeder/model"
	"gddgame.cc/galaxy/utils/def"
	"gddgame.cc/galaxy/utils/orm"
)

func AddEquips(context def.Context, equips map[int]int, number int, user *model.User) error {
	if equips == nil || len(equips) == 0 {
		return nil
	}
	var err error
	for equipId, num := range equips {
		num *= number
		data := make([]interface{}, num)
		for i := 0; i < num; i++ {
			data[i] = model.UserEquip{
				UserId:  user.Id,
				EquipId: equipId,
				Level:   0,
				UnitId:  "",
			}
		}
		if _, err = model.UserPropModel.Query().Save(true, data...); err != nil {
			return SystemExceptionDetail("添加装备失败", err)
		}
	}
	return nil
}

func RemoveEquips(context def.Context, equips map[int]int, number int, user *model.User) error {
	if equips == nil || len(equips) == 0 {
		return nil
	}
	var err error
	var uEquips []model.UserEquip
	var equipIds []int
	var uEquipMap map[int]int
	// 添加获取的道具
	if len(equips) == 0 {
		return nil
	}
	equipIds = make([]int, 0, len(equips))
	for key, _ := range equips {
		equipIds = append(equipIds, key)
	}
	if _, err = model.UserEquipModel.Query().Where("=", "user_id", user.Id).Where("in", "equip_id", equipIds).Find(&uEquips); err != nil {
		return SystemExceptionDetail("查找用户装备失败", err)
	}
	uEquipMap = map[int]int{}
	equipIds = []int{}
	for _, uEquip := range uEquips {
		if v, ok := uEquipMap[uEquip.EquipId]; !ok {
			uEquipMap[uEquip.EquipId] = 1
		} else {
			if v >= equips[uEquip.EquipId]*number {
				continue
			}
			uEquipMap[uEquip.EquipId] += 1
		}
		equipIds = append(equipIds, uEquip.Id)
	}

	for id, n := range equips {
		if v, ok := uEquipMap[id]; !ok {
			return ValidException("装备数量不足")
		} else if v < n*number {
			return ValidException("装备数量不足")
		}
	}

	if _, err := model.UserEquipModel.Query().Where("in", "id", equipIds).Delete(); err != nil {
		return SystemExceptionDetail("删除装备失败", err)
	}
	return nil
}
func GetEquips(context def.Context, userId int, updateTime *time.Time) ([]*model.PlayerEquip, error) {
	var err error
	var uEquips []model.UserEquip
	query := model.UserEquipModel.Query().Where("=", "user_id", userId)
	if updateTime != nil && updateTime.After(Env.Time()) {
		query.Where(">", "update_time", updateTime)
	}
	if _, err = query.Find(&uEquips); err != nil {
		return nil, SystemExceptionDetail("查找用户装备失败", err)
	}
	// 获取道具信息
	props := make([]*model.PlayerEquip, len(uEquips))
	for key := range uEquips {
		props[key] = model.NewPlayerEquip(&uEquips[key])
	}
	return props, nil
}

func DismantleEquip(context def.Context, userEquipId int, user *model.User) (userEquip *model.UserEquip, err error) {
	var uEquip model.UserEquip
	ok, _ := model.UserPropModel.Query().Where("=", "user_id", user.Id).Where("=", "id", userEquipId).One(&uEquip)
	if !ok {
		return nil, ValidException("装备不存在")
	}
	if uEquip.UnitId != "" {
		return nil, ValidException("装备使用中")
	}
	equip := Center.EquipMap[uEquip.EquipId]
	levelInfo := equip.Levels[uEquip.Level]

	if _, err := model.UserPropModel.PK(uEquip.Id).Delete(); err != nil {
		return nil, SystemExceptionDetail("分解装备失败", err)
	}

	if !UpdateReceive(context, levelInfo.DecomposeSlice, 1, user) {
		return nil, ValidException("无法执行")
	}
	return &uEquip, nil
}

func GetUserEquip(context def.Context, userEquipId int, user *model.User) (userEquip *model.UserEquip, err error) {
	ok, _ := model.UserPropModel.Query().Where("=", "user_id", user.Id).Where("=", "id", userEquipId).One(&userEquip)
	if !ok {
		return nil, ValidException("装备不存在")
	}
	return
}

func IntensifyEquip(context def.Context, userEquip *model.UserEquip, user *model.User, account *cooperated.Account, userUnit *model.UserUnit, unitInstance *cooperated.Unit) (err error) {
	equip := Center.EquipMap[userEquip.EquipId]
	if userEquip.Level+1 >= len(equip.Levels) {
		return ValidException("装备已是最高级")
	}
	levelInfo := equip.Levels[userEquip.Level]
	if !ValidRequire(context, levelInfo.RequireSlice, user, account, userUnit, unitInstance) {
		return ValidException("不满足升级条件")
	}
	if ok, consumeData := ValidConsume(context, levelInfo.IntensifySlice, 1, user, nil); !ok {
		return ValidException("无法升级")
	} else {
		if err := UpdateConsume(context, consumeData, user, nil); err != nil {
			return err
		}
	}

	if _, err := model.UserEquipModel.PK(userEquip.Id).Update(map[string]interface{}{
		"level": &orm.UpdateOperate{Operate: "+", Value: 1},
	}); err != nil {
		return SystemExceptionDetail("升级装备失败", err)
	}
	if userEquip.UnitId != "" {
		for index := range userUnit.Equips {
			if userUnit.Equips[index].UserEquipId == userEquip.Id {
				userUnit.Equips[index].Level += 1
				break
			}
		}
	}
	return
}

func PutOnEquip(context def.Context, userEquipId int, index int, location string, user *model.User, account *cooperated.Account, userUnit *model.UserUnit, unitInstance *cooperated.Unit) (err error) {
	var uEquip model.UserEquip
	ok, _ := model.UserEquipModel.Query().Where("=", "user_id", user.Id).Where("=", "id", userEquipId).One(&uEquip)
	if !ok {
		return ValidException("装备不存在")
	}
	if uEquip.UnitId != "" {
		return ValidException("装备使用中")
	}

	for ii, ee := range userUnit.Equips {
		if ee == nil {
			continue
		}
		if ee.Location == location && ee.Location != "" && ii != index {
			return ValidException("部队该位置已安装装备")
		}
	}
	equip := Center.EquipMap[uEquip.EquipId]
	if equip.Location != "" && equip.Location != location {
		return ValidException("装备位置错误")
	}

	levelInfo := equip.Levels[uEquip.Level]
	if !ValidRequire(context, levelInfo.RequireSlice, user, account, userUnit, unitInstance) {
		return ValidException("不满足使用条件")
	}
	if _, err := model.UserEquipModel.PK(uEquip.Id).Update(map[string]interface{}{
		"unit_id":  userUnit.Id,
		"location": location,
	}); err != nil {
		return SystemExceptionDetail("安装装备失败", err)
	}
	// 添加好装备，最后外部保存
	if len(userUnit.Equips) > index {
		if userUnit.Equips[index] != nil {
			// 卸载已有道具
			if err := PutOutEquip(context, userUnit.Equips[index].UserEquipId, user, userUnit); err != nil {
				return err
			}
		}
	}
	l := len(userUnit.Equips)
	if index >= l {
		userUnit.Equips = append(userUnit.Equips, make([]*model.EquipInUser, index-l+1)...)
	}
	userUnit.Equips[index] = &model.EquipInUser{
		UserEquipId: userEquipId,
		EquipId:     equip.Id,
		Location:    location,
		Level:       uEquip.Level,
	}
	return
}

func PutOutEquip(context def.Context, userEquipId int, user *model.User, userUnit *model.UserUnit) (err error) {
	var uEquip model.UserEquip
	ok, _ := model.UserEquipModel.Query().Where("=", "user_id", user.Id).Where("=", "id", userEquipId).One(&uEquip)
	if !ok {
		return ValidException("装备不存在")
	}
	if uEquip.UnitId == "" {
		return ValidException("装备未使用")
	}
	if uEquip.UnitId != userUnit.Id {
		return ValidException("装备使用中")
	}

	equipIndex := -1
	for index, ee := range userUnit.Equips {
		if ee == nil {
			continue
		}
		if ee.UserEquipId != userEquipId {
			continue
		}
		equipIndex = index
		break
	}
	if equipIndex == -1 {
		return ValidException("装备数据错误")
	}
	if _, err := model.UserEquipModel.PK(uEquip.Id).Update(map[string]interface{}{
		"unit_id":  0,
		"location": "",
	}); err != nil {
		return SystemExceptionDetail("卸载装备失败", err)
	}
	// 移除装备，最后外部保存
	userUnit.Equips[equipIndex] = nil
	return
}
